
<!DOCTYPE html>

<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta charset="utf-8" />
    <title>stacking_fault_static calculation style &#8212; iprPy 0.10.2 documentation</title>
    <link rel="stylesheet" href="../_static/basic.css" type="text/css" />
    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
    <script type="text/javascript" id="documentation_options" data-url_root="../" src="../_static/documentation_options.js"></script>
    <script type="text/javascript" src="../_static/jquery.js"></script>
    <script type="text/javascript" src="../_static/underscore.js"></script>
    <script type="text/javascript" src="../_static/doctools.js"></script>
    <script type="text/javascript" src="../_static/language_data.js"></script>
    <script crossorigin="anonymous" integrity="sha256-Ae2Vz/4ePdIu6ZyI/5ZGsYnb+m0JlOmKPjt6XZ9JJkA=" type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.4/require.min.js"></script>
    <script async="async" type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
    <script type="text/x-mathjax-config">MathJax.Hub.Config({"tex2jax": {"inlineMath": [["$", "$"], ["\\(", "\\)"]], "processEscapes": true, "ignoreClass": "document", "processClass": "math|output_area"}})</script>
    <link rel="index" title="Index" href="../genindex.html" />
    <link rel="search" title="Search" href="../search.html" />
    <link rel="next" title="surface_energy_static calculation style" href="surface_energy_static.html" />
    <link rel="prev" title="stacking_fault_map_2D calculation style" href="stacking_fault_map_2D.html" /> 
  </head><body>
    <div class="related" role="navigation" aria-label="related navigation">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="../genindex.html" title="General Index"
             accesskey="I">index</a></li>
        <li class="right" >
          <a href="../py-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="surface_energy_static.html" title="surface_energy_static calculation style"
             accesskey="N">next</a> |</li>
        <li class="right" >
          <a href="stacking_fault_map_2D.html" title="stacking_fault_map_2D calculation style"
             accesskey="P">previous</a> |</li>
        <li class="nav-item nav-item-0"><a href="../index.html">iprPy 0.10.2 documentation</a> &#187;</li>
          <li class="nav-item nav-item-1"><a href="../notebook_styles.html" accesskey="U">Jupyter Demonstration Notebooks</a> &#187;</li> 
      </ul>
    </div>  

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body" role="main">
            
  
<style>
/* CSS for nbsphinx extension */

/* remove conflicting styling from Sphinx themes */
div.nbinput.container,
div.nbinput.container div.prompt,
div.nbinput.container div.input_area,
div.nbinput.container div[class*=highlight],
div.nbinput.container div[class*=highlight] pre,
div.nboutput.container,
div.nboutput.container div.prompt,
div.nboutput.container div.output_area,
div.nboutput.container div[class*=highlight],
div.nboutput.container div[class*=highlight] pre {
    background: none;
    border: none;
    padding: 0 0;
    margin: 0;
    box-shadow: none;
}

/* avoid gaps between output lines */
div.nboutput.container div[class*=highlight] pre {
    line-height: normal;
}

/* input/output containers */
div.nbinput.container,
div.nboutput.container {
    display: -webkit-flex;
    display: flex;
    align-items: flex-start;
    margin: 0;
    width: 100%;
}
@media (max-width: 540px) {
    div.nbinput.container,
    div.nboutput.container {
        flex-direction: column;
    }
}

/* input container */
div.nbinput.container {
    padding-top: 5px;
}

/* last container */
div.nblast.container {
    padding-bottom: 5px;
}

/* input prompt */
div.nbinput.container div.prompt pre {
    color: #307FC1;
}

/* output prompt */
div.nboutput.container div.prompt pre {
    color: #BF5B3D;
}

/* all prompts */
div.nbinput.container div.prompt,
div.nboutput.container div.prompt {
    width: 4.5ex;
    padding-top: 5px;
    position: relative;
    user-select: none;
}

div.nbinput.container div.prompt > div,
div.nboutput.container div.prompt > div {
    position: absolute;
    right: 0;
    margin-right: 0.3ex;
}

@media (max-width: 540px) {
    div.nbinput.container div.prompt,
    div.nboutput.container div.prompt {
        width: unset;
        text-align: left;
        padding: 0.4em;
    }
    div.nboutput.container div.prompt.empty {
        padding: 0;
    }

    div.nbinput.container div.prompt > div,
    div.nboutput.container div.prompt > div {
        position: unset;
    }
}

/* disable scrollbars on prompts */
div.nbinput.container div.prompt pre,
div.nboutput.container div.prompt pre {
    overflow: hidden;
}

/* input/output area */
div.nbinput.container div.input_area,
div.nboutput.container div.output_area {
    -webkit-flex: 1;
    flex: 1;
    overflow: auto;
}
@media (max-width: 540px) {
    div.nbinput.container div.input_area,
    div.nboutput.container div.output_area {
        width: 100%;
    }
}

/* input area */
div.nbinput.container div.input_area {
    border: 1px solid #e0e0e0;
    border-radius: 2px;
    background: #f5f5f5;
}

/* override MathJax center alignment in output cells */
div.nboutput.container div[class*=MathJax] {
    text-align: left !important;
}

/* override sphinx.ext.imgmath center alignment in output cells */
div.nboutput.container div.math p {
    text-align: left;
}

/* standard error */
div.nboutput.container div.output_area.stderr {
    background: #fdd;
}

/* ANSI colors */
.ansi-black-fg { color: #3E424D; }
.ansi-black-bg { background-color: #3E424D; }
.ansi-black-intense-fg { color: #282C36; }
.ansi-black-intense-bg { background-color: #282C36; }
.ansi-red-fg { color: #E75C58; }
.ansi-red-bg { background-color: #E75C58; }
.ansi-red-intense-fg { color: #B22B31; }
.ansi-red-intense-bg { background-color: #B22B31; }
.ansi-green-fg { color: #00A250; }
.ansi-green-bg { background-color: #00A250; }
.ansi-green-intense-fg { color: #007427; }
.ansi-green-intense-bg { background-color: #007427; }
.ansi-yellow-fg { color: #DDB62B; }
.ansi-yellow-bg { background-color: #DDB62B; }
.ansi-yellow-intense-fg { color: #B27D12; }
.ansi-yellow-intense-bg { background-color: #B27D12; }
.ansi-blue-fg { color: #208FFB; }
.ansi-blue-bg { background-color: #208FFB; }
.ansi-blue-intense-fg { color: #0065CA; }
.ansi-blue-intense-bg { background-color: #0065CA; }
.ansi-magenta-fg { color: #D160C4; }
.ansi-magenta-bg { background-color: #D160C4; }
.ansi-magenta-intense-fg { color: #A03196; }
.ansi-magenta-intense-bg { background-color: #A03196; }
.ansi-cyan-fg { color: #60C6C8; }
.ansi-cyan-bg { background-color: #60C6C8; }
.ansi-cyan-intense-fg { color: #258F8F; }
.ansi-cyan-intense-bg { background-color: #258F8F; }
.ansi-white-fg { color: #C5C1B4; }
.ansi-white-bg { background-color: #C5C1B4; }
.ansi-white-intense-fg { color: #A1A6B2; }
.ansi-white-intense-bg { background-color: #A1A6B2; }

.ansi-default-inverse-fg { color: #FFFFFF; }
.ansi-default-inverse-bg { background-color: #000000; }

.ansi-bold { font-weight: bold; }
.ansi-underline { text-decoration: underline; }


div.nbinput.container div.input_area div[class*=highlight] > pre,
div.nboutput.container div.output_area div[class*=highlight] > pre,
div.nboutput.container div.output_area div[class*=highlight].math,
div.nboutput.container div.output_area.rendered_html,
div.nboutput.container div.output_area > div.output_javascript,
div.nboutput.container div.output_area:not(.rendered_html) > img{
    padding: 5px;
}

/* fix copybtn overflow problem in chromium (needed for 'sphinx_copybutton') */
div.nbinput.container div.input_area > div[class^='highlight'],
div.nboutput.container div.output_area > div[class^='highlight']{
    overflow-y: hidden;
}

/* hide copybtn icon on prompts (needed for 'sphinx_copybutton') */
.prompt a.copybtn {
    display: none;
}

/* Some additional styling taken form the Jupyter notebook CSS */
div.rendered_html table {
  border: none;
  border-collapse: collapse;
  border-spacing: 0;
  color: black;
  font-size: 12px;
  table-layout: fixed;
}
div.rendered_html thead {
  border-bottom: 1px solid black;
  vertical-align: bottom;
}
div.rendered_html tr,
div.rendered_html th,
div.rendered_html td {
  text-align: right;
  vertical-align: middle;
  padding: 0.5em 0.5em;
  line-height: normal;
  white-space: normal;
  max-width: none;
  border: none;
}
div.rendered_html th {
  font-weight: bold;
}
div.rendered_html tbody tr:nth-child(odd) {
  background: #f5f5f5;
}
div.rendered_html tbody tr:hover {
  background: rgba(66, 165, 245, 0.2);
}
</style>
<div class="section" id="stacking_fault_static-calculation-style">
<h1>stacking_fault_static calculation style<a class="headerlink" href="#stacking_fault_static-calculation-style" title="Permalink to this headline">¶</a></h1>
<p><strong>Lucas M. Hale</strong>, <a class="reference external" href="mailto:lucas&#46;hale&#37;&#52;&#48;nist&#46;gov?Subject=ipr-demo">lucas<span>&#46;</span>hale<span>&#64;</span>nist<span>&#46;</span>gov</a>, <em>Materials Science and Engineering Division, NIST</em>.</p>
<div class="section" id="Introduction">
<h2>Introduction<a class="headerlink" href="#Introduction" title="Permalink to this headline">¶</a></h2>
<p>The stacking_fault_static calculation style evaluates the energy of a single generalized stacking fault shift along a specified crystallographic plane.</p>
<div class="section" id="Version-notes">
<h3>Version notes<a class="headerlink" href="#Version-notes" title="Permalink to this headline">¶</a></h3>
<ul class="simple">
<li><p>2018-07-09: Notebook added.</p></li>
<li><p>2019-07-30: Description updated and small changes due to iprPy version.</p></li>
<li><p>2020-05-22: Version 0.10 update - potentials now loaded from database.</p></li>
<li><p>2020-09-22: Calculation updated to use atomman.defect.StackingFault class. Setup and parameter definition streamlined.</p></li>
</ul>
</div>
<div class="section" id="Additional-dependencies">
<h3>Additional dependencies<a class="headerlink" href="#Additional-dependencies" title="Permalink to this headline">¶</a></h3>
</div>
<div class="section" id="Disclaimers">
<h3>Disclaimers<a class="headerlink" href="#Disclaimers" title="Permalink to this headline">¶</a></h3>
<ul class="simple">
<li><p><a class="reference external" href="http://www.nist.gov/public_affairs/disclaimer.cfm">NIST disclaimers</a></p></li>
<li><p>The system’s dimension perpendicular to the fault plane should be large to minimize the interaction of the free surface and the stacking fault.</p></li>
</ul>
</div>
</div>
<div class="section" id="Method-and-Theory">
<h2>Method and Theory<a class="headerlink" href="#Method-and-Theory" title="Permalink to this headline">¶</a></h2>
<p>First, an initial system is generated. This is accomplished using atomman.defect.StackingFault, which</p>
<ol class="arabic simple">
<li><p>Starts with a unit cell system.</p></li>
<li><p>Generates a transformed system by rotating the unit cell such that the new system’s box vectors correspond to crystallographic directions, and filled in with atoms to remain a perfect bulk cell when the three boundaries are periodic.</p></li>
<li><p>All atoms are shifted by a fractional amount of the box vectors if needed.</p></li>
<li><p>A supercell system is constructed by combining multiple replicas of the transformed system.</p></li>
<li><p>The system is then cut by making one of the box boundaries non-periodic. A limitation placed on the calculation is that the normal to the cut plane must correspond to one of the three Cartesian (<span class="math notranslate nohighlight">\(x\)</span>, <span class="math notranslate nohighlight">\(y\)</span>, or <span class="math notranslate nohighlight">\(z\)</span>) axes. If true, then of the system’s three box vectors (<span class="math notranslate nohighlight">\(\vec{a}\)</span>, <span class="math notranslate nohighlight">\(\vec{b}\)</span>, and <span class="math notranslate nohighlight">\(\vec{c}\)</span>), two will be parallel to the plane, and the third will not. The non-parallel box vector is called the cutboxvector, and for LAMMPS compatible systems, the
following conditions can be used to check the system’s compatibility:</p>
<ul class="simple">
<li><p>cutboxvector = ‘c’: all systems allowed.</p></li>
<li><p>cutboxvector = ‘b’: the system’s yz tilt must be zero.</p></li>
<li><p>cutboxvector = ‘a’: the system’s xy and xz tilts must be zero.</p></li>
</ul>
</li>
</ol>
<p>A LAMMPS simulation performs an energy/force minimization on the system where the atoms are confined to only relax along the Cartesian direction normal to the cut plane.</p>
<p>A mathematical fault plane parallel to the cut plane is defined in the middle of the system. A generalized stacking fault system can then be created by shifting all atoms on one side of the fault plane by a vector, <span class="math notranslate nohighlight">\(\vec{s}\)</span>. The shifted system is then relaxed using the same confined energy/force minimization used on the non-shifted system. The generalized stacking fault energy, <span class="math notranslate nohighlight">\(\gamma\)</span>, can then be computed by comparing the total energy of the system, <span class="math notranslate nohighlight">\(E_{total}\)</span>, before and
after <span class="math notranslate nohighlight">\(\vec{s}\)</span> is applied</p>
<div class="math notranslate nohighlight">
\[\gamma(\vec{s}) = \frac{E_{total}(\vec{s}) - E_{total}(\vec{0})}{A},\]</div>
<p>where <span class="math notranslate nohighlight">\(A\)</span> is the area of the fault plane, which can be computed using the two box vectors, <span class="math notranslate nohighlight">\(\vec{a_1}\)</span> and <span class="math notranslate nohighlight">\(\vec{a_2}\)</span>, that are not the cutboxvector.</p>
<div class="math notranslate nohighlight">
\[A = \left| \vec{a_1} \times \vec{a_2} \right|,\]</div>
<p>Additionally, the relaxation normal to the glide plane is characterized using the center of mass of the atoms above and below the cut plane. Notably, the component of the center of mass normal to the glide/cut plane is calculated for the two halves of the the system, and the difference is computed</p>
<div class="math notranslate nohighlight">
\[\delta = \left&lt;x\right&gt;^{+} - \left&lt;x\right&gt;^{-}.\]</div>
<p>The relaxation normal is then taken as the change in the center of mass difference after the shift is applied.</p>
<div class="math notranslate nohighlight">
\[\Delta\delta = \delta(\vec{s}) - \delta(\vec{0}).\]</div>
</div>
<div class="section" id="Demonstration">
<h2>Demonstration<a class="headerlink" href="#Demonstration" title="Permalink to this headline">¶</a></h2>
<div class="section" id="1.-Library-imports">
<h3>1. Library imports<a class="headerlink" href="#1.-Library-imports" title="Permalink to this headline">¶</a></h3>
<p>Import libraries needed by the calculation. The external libraries used are:</p>
<ul class="simple">
<li><p><a class="reference external" href="http://www.numpy.org/">numpy</a></p></li>
<li><p><a class="reference external" href="https://github.com/usnistgov/atomman">atomman</a></p></li>
<li><p><a class="reference external" href="https://github.com/usnistgov/iprPy">iprPy</a></p></li>
</ul>
<div class="nbinput docutils container">
<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[1]:
</pre></div>
</div>
<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
<span></span><span class="c1"># Standard library imports</span>
<span class="kn">from</span> <span class="nn">pathlib</span> <span class="k">import</span> <span class="n">Path</span>
<span class="kn">import</span> <span class="nn">os</span>
<span class="kn">import</span> <span class="nn">shutil</span>
<span class="kn">import</span> <span class="nn">datetime</span>

<span class="c1"># http://www.numpy.org/</span>
<span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>

<span class="c1"># https://github.com/usnistgov/atomman</span>
<span class="kn">import</span> <span class="nn">atomman</span> <span class="k">as</span> <span class="nn">am</span>
<span class="kn">import</span> <span class="nn">atomman.lammps</span> <span class="k">as</span> <span class="nn">lmp</span>
<span class="kn">import</span> <span class="nn">atomman.unitconvert</span> <span class="k">as</span> <span class="nn">uc</span>

<span class="c1"># https://github.com/usnistgov/iprPy</span>
<span class="kn">import</span> <span class="nn">iprPy</span>

<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Notebook last executed on&#39;</span><span class="p">,</span> <span class="n">datetime</span><span class="o">.</span><span class="n">date</span><span class="o">.</span><span class="n">today</span><span class="p">(),</span> <span class="s1">&#39;using iprPy version&#39;</span><span class="p">,</span> <span class="n">iprPy</span><span class="o">.</span><span class="n">__version__</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="nboutput nblast docutils container">
<div class="prompt empty docutils container">
</div>
<div class="output_area docutils container">
<div class="highlight"><pre>
Notebook last executed on 2020-09-22 using iprPy version 0.10.2
</pre></div></div>
</div>
<div class="section" id="1.2.-Default-calculation-setup">
<h4>1.2. Default calculation setup<a class="headerlink" href="#1.2.-Default-calculation-setup" title="Permalink to this headline">¶</a></h4>
<div class="nbinput nblast docutils container">
<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[2]:
</pre></div>
</div>
<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
<span></span><span class="c1"># Specify calculation style</span>
<span class="n">calc_style</span> <span class="o">=</span> <span class="s1">&#39;stacking_fault_static&#39;</span>

<span class="c1"># If workingdir is already set, then do nothing (already in correct folder)</span>
<span class="k">try</span><span class="p">:</span>
    <span class="n">workingdir</span> <span class="o">=</span> <span class="n">workingdir</span>

<span class="c1"># Change to workingdir if not already there</span>
<span class="k">except</span><span class="p">:</span>
    <span class="n">workingdir</span> <span class="o">=</span> <span class="n">Path</span><span class="p">(</span><span class="s1">&#39;calculationfiles&#39;</span><span class="p">,</span> <span class="n">calc_style</span><span class="p">)</span>
    <span class="k">if</span> <span class="ow">not</span> <span class="n">workingdir</span><span class="o">.</span><span class="n">is_dir</span><span class="p">():</span>
        <span class="n">workingdir</span><span class="o">.</span><span class="n">mkdir</span><span class="p">(</span><span class="n">parents</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
    <span class="n">os</span><span class="o">.</span><span class="n">chdir</span><span class="p">(</span><span class="n">workingdir</span><span class="p">)</span>

<span class="c1"># Initialize connection to library</span>
<span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="s1">&#39;C:/Users/lmh1/Documents/potentials_nist_gov/password.txt&#39;</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
    <span class="n">user</span><span class="p">,</span> <span class="n">pswd</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">read</span><span class="p">()</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span><span class="o">.</span><span class="n">split</span><span class="p">()</span>
<span class="n">library</span> <span class="o">=</span> <span class="n">iprPy</span><span class="o">.</span><span class="n">Library</span><span class="p">(</span><span class="n">load</span><span class="o">=</span><span class="p">[</span><span class="s1">&#39;lammps_potentials&#39;</span><span class="p">],</span> <span class="n">username</span><span class="o">=</span><span class="n">user</span><span class="p">,</span> <span class="n">password</span><span class="o">=</span><span class="n">pswd</span><span class="p">)</span>
</pre></div>
</div>
</div>
</div>
</div>
<div class="section" id="2.-Assign-values-for-the-calculation’s-run-parameters">
<h3>2. Assign values for the calculation’s run parameters<a class="headerlink" href="#2.-Assign-values-for-the-calculation’s-run-parameters" title="Permalink to this headline">¶</a></h3>
<div class="section" id="2.1-Specify-system-specific-paths">
<h4>2.1 Specify system-specific paths<a class="headerlink" href="#2.1-Specify-system-specific-paths" title="Permalink to this headline">¶</a></h4>
<ul class="simple">
<li><p><strong>lammps_command</strong> is the LAMMPS command to use.</p></li>
<li><p><strong>mpi_command</strong> MPI command for running LAMMPS in parallel. A value of None will run simulations serially.</p></li>
</ul>
<div class="nbinput nblast docutils container">
<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[3]:
</pre></div>
</div>
<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
<span></span><span class="n">lammps_command</span> <span class="o">=</span> <span class="s1">&#39;lmp_serial&#39;</span>
<span class="n">mpi_command</span> <span class="o">=</span> <span class="kc">None</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="2.2.-Load-interatomic-potential">
<h4>2.2. Load interatomic potential<a class="headerlink" href="#2.2.-Load-interatomic-potential" title="Permalink to this headline">¶</a></h4>
<ul class="simple">
<li><p><strong>potential_name</strong> gives the name of the potential_LAMMPS reference record in the iprPy library to use for the calculation.</p></li>
<li><p><strong>potential</strong> is an atomman.lammps.Potential object (required).</p></li>
</ul>
<div class="nbinput nblast docutils container">
<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[4]:
</pre></div>
</div>
<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
<span></span><span class="n">potential_name</span> <span class="o">=</span> <span class="s1">&#39;1999--Mishin-Y--Ni--LAMMPS--ipr1&#39;</span>

<span class="c1"># Retrieve potential and parameter file(s)</span>
<span class="n">potential</span> <span class="o">=</span> <span class="n">library</span><span class="o">.</span><span class="n">get_lammps_potential</span><span class="p">(</span><span class="nb">id</span><span class="o">=</span><span class="n">potential_name</span><span class="p">,</span> <span class="n">getfiles</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="2.3.-Load-initial-unit-cell-system">
<h4>2.3. Load initial unit cell system<a class="headerlink" href="#2.3.-Load-initial-unit-cell-system" title="Permalink to this headline">¶</a></h4>
<ul class="simple">
<li><p><strong>ucell</strong> is an atomman.System representing a fundamental unit cell of the system (required). Here, this is loaded from the database for the prototype.</p></li>
</ul>
<div class="nbinput docutils container">
<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[5]:
</pre></div>
</div>
<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
<span></span><span class="c1"># Create ucell by loading prototype record</span>
<span class="n">ucell</span> <span class="o">=</span> <span class="n">am</span><span class="o">.</span><span class="n">load</span><span class="p">(</span><span class="s1">&#39;crystal&#39;</span><span class="p">,</span> <span class="n">potential</span><span class="o">=</span><span class="n">potential</span><span class="p">,</span> <span class="n">family</span><span class="o">=</span><span class="s1">&#39;A1--Cu--fcc&#39;</span><span class="p">,</span> <span class="n">database</span><span class="o">=</span><span class="n">library</span><span class="p">)</span>

<span class="nb">print</span><span class="p">(</span><span class="n">ucell</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="nboutput nblast docutils container">
<div class="prompt empty docutils container">
</div>
<div class="output_area docutils container">
<div class="highlight"><pre>
avect =  [ 3.520,  0.000,  0.000]
bvect =  [ 0.000,  3.520,  0.000]
cvect =  [ 0.000,  0.000,  3.520]
origin = [ 0.000,  0.000,  0.000]
natoms = 4
natypes = 1
symbols = (&#39;Ni&#39;,)
pbc = [ True  True  True]
per-atom properties = [&#39;atype&#39;, &#39;pos&#39;]
     id |   atype |  pos[0] |  pos[1] |  pos[2]
      0 |       1 |   0.000 |   0.000 |   0.000
      1 |       1 |   0.000 |   1.760 |   1.760
      2 |       1 |   1.760 |   0.000 |   1.760
      3 |       1 |   1.760 |   1.760 |   0.000
</pre></div></div>
</div>
</div>
<div class="section" id="2.4.-Specify-the-defect-parameters">
<h4>2.4. Specify the defect parameters<a class="headerlink" href="#2.4.-Specify-the-defect-parameters" title="Permalink to this headline">¶</a></h4>
<ul class="simple">
<li><p><strong>hkl</strong> gives the Miller (hkl) or Miller-Bravais (hkil) plane to create the free surface on.</p></li>
<li><p><strong>cutboxvector</strong> specifies which of the three box vectors (‘a’, ‘b’, or ‘c’) is to be made non-periodic to create the free surface.</p></li>
<li><p><strong>shiftindex</strong> can be used for complex crystals to specify different termination planes.</p></li>
<li><p><strong>a1vect_uvw, a2vect_uvw</strong> specify two non-parallel Miller crystal vectors within the fault plane corresponding to full planar shifts from one perfect crystal configuration to another.</p></li>
<li><p><strong>a1, a2</strong> are the fractional shifts along a1vect_uvw, a2vect_uvw to apply to the system.</p></li>
</ul>
<div class="nbinput nblast docutils container">
<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[6]:
</pre></div>
</div>
<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
<span></span><span class="n">hkl</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">]</span>
<span class="n">cutboxvector</span> <span class="o">=</span> <span class="s1">&#39;c&#39;</span>
<span class="n">shiftindex</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">a1vect_uvw</span> <span class="o">=</span> <span class="p">[</span> <span class="mf">0.0</span><span class="p">,</span><span class="o">-</span><span class="mf">0.5</span><span class="p">,</span> <span class="mf">0.5</span><span class="p">]</span>
<span class="n">a2vect_uvw</span> <span class="o">=</span> <span class="p">[</span> <span class="mf">0.5</span><span class="p">,</span><span class="o">-</span><span class="mf">0.5</span><span class="p">,</span> <span class="mf">0.0</span><span class="p">]</span>
<span class="n">a1</span> <span class="o">=</span> <span class="mf">0.5</span>
<span class="n">a2</span> <span class="o">=</span> <span class="mf">0.0</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="2.5.-Modify-system">
<h4>2.5. Modify system<a class="headerlink" href="#2.5.-Modify-system" title="Permalink to this headline">¶</a></h4>
<ul class="simple">
<li><p><strong>sizemults</strong> list of three integers specifying how many times the ucell vectors of <span class="math notranslate nohighlight">\(a\)</span>, <span class="math notranslate nohighlight">\(b\)</span> and <span class="math notranslate nohighlight">\(c\)</span> are replicated in creating system.</p></li>
<li><p><strong>minwidth</strong> specifies a minimum width that the system should be along the cutboxvector direction. The given sizemult in that direction will be increased if needed to ensure that the system is at least this wide.</p></li>
</ul>
<div class="nbinput nblast docutils container">
<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[7]:
</pre></div>
</div>
<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
<span></span><span class="n">sizemults</span> <span class="o">=</span> <span class="p">[</span><span class="mi">5</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">10</span><span class="p">]</span>
<span class="n">minwidth</span> <span class="o">=</span> <span class="n">uc</span><span class="o">.</span><span class="n">set_in_units</span><span class="p">(</span><span class="mf">0.0</span><span class="p">,</span> <span class="s1">&#39;angstrom&#39;</span><span class="p">)</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="2.6.-Specify-calculation-specific-run-parameters">
<h4>2.6. Specify calculation-specific run parameters<a class="headerlink" href="#2.6.-Specify-calculation-specific-run-parameters" title="Permalink to this headline">¶</a></h4>
<ul class="simple">
<li><p><strong>energytolerance</strong> is the energy tolerance to use during the minimizations. This is unitless.</p></li>
<li><p><strong>forcetolerance</strong> is the force tolerance to use during the minimizations. This is in energy/length units.</p></li>
<li><p><strong>maxiterations</strong> is the maximum number of minimization iterations to use.</p></li>
<li><p><strong>maxevaluations</strong> is the maximum number of minimization evaluations to use.</p></li>
<li><p><strong>maxatommotion</strong> is the largest distance that an atom is allowed to move during a minimization iteration. This is in length units.</p></li>
</ul>
<div class="nbinput nblast docutils container">
<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[8]:
</pre></div>
</div>
<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
<span></span><span class="n">energytolerance</span> <span class="o">=</span> <span class="mf">1e-8</span>
<span class="n">forcetolerance</span> <span class="o">=</span> <span class="n">uc</span><span class="o">.</span><span class="n">set_in_units</span><span class="p">(</span><span class="mf">0.0</span><span class="p">,</span> <span class="s1">&#39;eV/angstrom&#39;</span><span class="p">)</span>
<span class="n">maxiterations</span> <span class="o">=</span> <span class="mi">10000</span>
<span class="n">maxevaluations</span> <span class="o">=</span> <span class="mi">100000</span>
<span class="n">maxatommotion</span> <span class="o">=</span> <span class="n">uc</span><span class="o">.</span><span class="n">set_in_units</span><span class="p">(</span><span class="mf">0.01</span><span class="p">,</span> <span class="s1">&#39;angstrom&#39;</span><span class="p">)</span>
</pre></div>
</div>
</div>
</div>
</div>
<div class="section" id="3.-Define-calculation-function(s)-and-generate-template-LAMMPS-script(s)">
<h3>3. Define calculation function(s) and generate template LAMMPS script(s)<a class="headerlink" href="#3.-Define-calculation-function(s)-and-generate-template-LAMMPS-script(s)" title="Permalink to this headline">¶</a></h3>
<div class="section" id="3.1-sfmin.template">
<h4>3.1 sfmin.template<a class="headerlink" href="#3.1-sfmin.template" title="Permalink to this headline">¶</a></h4>
<div class="nbinput nblast docutils container">
<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[9]:
</pre></div>
</div>
<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
<span></span><span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="s1">&#39;sfmin.template&#39;</span><span class="p">,</span> <span class="s1">&#39;w&#39;</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
    <span class="n">f</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s2">&quot;&quot;&quot;#LAMMPS input script that performs an energy minimization</span>
<span class="s2">#for a system with a stacking fault</span>

<span class="s2">box tilt large</span>

<span class="s2">&lt;atomman_system_pair_info&gt;</span>

<span class="s2">&lt;fix_cut_setforce&gt;</span>

<span class="s2">thermo_style custom step lx ly lz pxx pyy pzz pe</span>
<span class="s2">thermo_modify format float </span><span class="si">%.13e</span><span class="s2"></span>

<span class="s2">compute peatom all pe/atom</span>

<span class="s2">min_modify dmax &lt;dmax&gt;</span>

<span class="s2">dump dumpit all custom &lt;maxeval&gt; &lt;sim_directory&gt;*.dump id type x y z c_peatom</span>
<span class="s2">dump_modify dumpit format &lt;dump_modify_format&gt;</span>

<span class="s2">minimize &lt;etol&gt; &lt;ftol&gt; &lt;maxiter&gt; &lt;maxeval&gt;&quot;&quot;&quot;</span><span class="p">)</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="3.2-stackingfaultrelax()">
<h4>3.2 stackingfaultrelax()<a class="headerlink" href="#3.2-stackingfaultrelax()" title="Permalink to this headline">¶</a></h4>
<div class="nbinput nblast docutils container">
<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[10]:
</pre></div>
</div>
<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
<span></span><span class="k">def</span> <span class="nf">stackingfaultrelax</span><span class="p">(</span><span class="n">lammps_command</span><span class="p">,</span> <span class="n">system</span><span class="p">,</span> <span class="n">potential</span><span class="p">,</span>
                       <span class="n">mpi_command</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">sim_directory</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span>
                       <span class="n">cutboxvector</span><span class="o">=</span><span class="s1">&#39;c&#39;</span><span class="p">,</span>
                       <span class="n">etol</span><span class="o">=</span><span class="mf">0.0</span><span class="p">,</span> <span class="n">ftol</span><span class="o">=</span><span class="mf">0.0</span><span class="p">,</span>
                       <span class="n">maxiter</span><span class="o">=</span><span class="mi">10000</span><span class="p">,</span> <span class="n">maxeval</span><span class="o">=</span><span class="mi">100000</span><span class="p">,</span>
                       <span class="n">dmax</span><span class="o">=</span><span class="n">uc</span><span class="o">.</span><span class="n">set_in_units</span><span class="p">(</span><span class="mf">0.01</span><span class="p">,</span> <span class="s1">&#39;angstrom&#39;</span><span class="p">),</span>
                       <span class="n">lammps_date</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;</span>
<span class="sd">    Perform a stacking fault relaxation simulation for a single faultshift.</span>

<span class="sd">    Parameters</span>
<span class="sd">    ----------</span>
<span class="sd">    lammps_command :str</span>
<span class="sd">        Command for running LAMMPS.</span>
<span class="sd">    system : atomman.System</span>
<span class="sd">        The system containing a stacking fault.</span>
<span class="sd">    potential : atomman.lammps.Potential</span>
<span class="sd">        The LAMMPS implemented potential to use.</span>
<span class="sd">    mpi_command : str, optional</span>
<span class="sd">        The MPI command for running LAMMPS in parallel.  If not given, LAMMPS</span>
<span class="sd">        will run serially.</span>
<span class="sd">    sim_directory : str, optional</span>
<span class="sd">        The path to the directory to perform the simulation in.  If not</span>
<span class="sd">        given, will use the current working directory.</span>
<span class="sd">    cutboxvector : str, optional</span>
<span class="sd">        Indicates which of the three system box vectors, &#39;a&#39;, &#39;b&#39;, or &#39;c&#39;, has</span>
<span class="sd">        the non-periodic boundary (default is &#39;c&#39;).  Fault plane normal is</span>
<span class="sd">        defined by the cross of the other two box vectors.</span>
<span class="sd">    etol : float, optional</span>
<span class="sd">        The energy tolerance for the structure minimization. This value is</span>
<span class="sd">        unitless. (Default is 0.0).</span>
<span class="sd">    ftol : float, optional</span>
<span class="sd">        The force tolerance for the structure minimization. This value is in</span>
<span class="sd">        units of force. (Default is 0.0).</span>
<span class="sd">    maxiter : int, optional</span>
<span class="sd">        The maximum number of minimization iterations to use (default is</span>
<span class="sd">        10000).</span>
<span class="sd">    maxeval : int, optional</span>
<span class="sd">        The maximum number of minimization evaluations to use (default is</span>
<span class="sd">        100000).</span>
<span class="sd">    dmax : float, optional</span>
<span class="sd">        The maximum distance in length units that any atom is allowed to relax</span>
<span class="sd">        in any direction during a single minimization iteration (default is</span>
<span class="sd">        0.01 Angstroms).</span>
<span class="sd">    lammps_date : datetime.date or None, optional</span>
<span class="sd">        The date version of the LAMMPS executable.  If None, will be identified</span>
<span class="sd">        from the lammps_command (default is None).</span>

<span class="sd">    Returns</span>
<span class="sd">    -------</span>
<span class="sd">    dict</span>
<span class="sd">        Dictionary of results consisting of keys:</span>

<span class="sd">        - **&#39;logfile&#39;** (*str*) - The filename of the LAMMPS log file.</span>
<span class="sd">        - **&#39;dumpfile&#39;** (*str*) - The filename of the LAMMPS dump file</span>
<span class="sd">          of the relaxed system.</span>
<span class="sd">        - **&#39;system&#39;** (*atomman.System*) - The relaxed system.</span>
<span class="sd">        - **&#39;E_total&#39;** (*float*) - The total potential energy of the relaxed</span>
<span class="sd">          system.</span>

<span class="sd">    Raises</span>
<span class="sd">    ------</span>
<span class="sd">    ValueError</span>
<span class="sd">        For invalid cutboxvectors.</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="c1"># Build filedict if function was called from iprPy</span>
    <span class="k">try</span><span class="p">:</span>
        <span class="k">assert</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="n">pkg_name</span>
        <span class="n">calc</span> <span class="o">=</span> <span class="n">iprPy</span><span class="o">.</span><span class="n">load_calculation</span><span class="p">(</span><span class="n">calculation_style</span><span class="p">)</span>
        <span class="n">filedict</span> <span class="o">=</span> <span class="n">calc</span><span class="o">.</span><span class="n">filedict</span>
    <span class="k">except</span><span class="p">:</span>
        <span class="n">filedict</span> <span class="o">=</span> <span class="p">{}</span>

    <span class="c1"># Give correct LAMMPS fix setforce command</span>
    <span class="k">if</span> <span class="n">cutboxvector</span> <span class="o">==</span> <span class="s1">&#39;a&#39;</span><span class="p">:</span>
        <span class="n">fix_cut_setforce</span> <span class="o">=</span> <span class="s1">&#39;fix cut all setforce NULL 0 0&#39;</span>
    <span class="k">elif</span> <span class="n">cutboxvector</span> <span class="o">==</span> <span class="s1">&#39;b&#39;</span><span class="p">:</span>
        <span class="n">fix_cut_setforce</span> <span class="o">=</span> <span class="s1">&#39;fix cut all setforce 0 NULL 0&#39;</span>
    <span class="k">elif</span> <span class="n">cutboxvector</span> <span class="o">==</span> <span class="s1">&#39;c&#39;</span><span class="p">:</span>
        <span class="n">fix_cut_setforce</span> <span class="o">=</span> <span class="s1">&#39;fix cut all setforce 0 0 NULL&#39;</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">&#39;Invalid cutboxvector&#39;</span><span class="p">)</span>

    <span class="k">if</span> <span class="n">sim_directory</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
        <span class="c1"># Create sim_directory if it doesn&#39;t exist</span>
        <span class="n">sim_directory</span> <span class="o">=</span> <span class="n">Path</span><span class="p">(</span><span class="n">sim_directory</span><span class="p">)</span>
        <span class="k">if</span> <span class="ow">not</span> <span class="n">sim_directory</span><span class="o">.</span><span class="n">is_dir</span><span class="p">():</span>
            <span class="n">sim_directory</span><span class="o">.</span><span class="n">mkdir</span><span class="p">()</span>
        <span class="n">sim_directory</span> <span class="o">=</span> <span class="n">sim_directory</span><span class="o">.</span><span class="n">as_posix</span><span class="p">()</span><span class="o">+</span><span class="s1">&#39;/&#39;</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="c1"># Set sim_directory if is None</span>
        <span class="n">sim_directory</span> <span class="o">=</span> <span class="s1">&#39;&#39;</span>

    <span class="c1"># Get lammps units</span>
    <span class="n">lammps_units</span> <span class="o">=</span> <span class="n">lmp</span><span class="o">.</span><span class="n">style</span><span class="o">.</span><span class="n">unit</span><span class="p">(</span><span class="n">potential</span><span class="o">.</span><span class="n">units</span><span class="p">)</span>

    <span class="c1">#Get lammps version date</span>
    <span class="k">if</span> <span class="n">lammps_date</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
        <span class="n">lammps_date</span> <span class="o">=</span> <span class="n">lmp</span><span class="o">.</span><span class="n">checkversion</span><span class="p">(</span><span class="n">lammps_command</span><span class="p">)[</span><span class="s1">&#39;date&#39;</span><span class="p">]</span>

    <span class="c1"># Define lammps variables</span>
    <span class="n">lammps_variables</span> <span class="o">=</span> <span class="p">{}</span>
    <span class="n">system_info</span> <span class="o">=</span> <span class="n">system</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="s1">&#39;atom_data&#39;</span><span class="p">,</span>
                              <span class="n">f</span><span class="o">=</span><span class="n">Path</span><span class="p">(</span><span class="n">sim_directory</span><span class="p">,</span> <span class="s1">&#39;system.dat&#39;</span><span class="p">)</span><span class="o">.</span><span class="n">as_posix</span><span class="p">(),</span>
                              <span class="n">potential</span><span class="o">=</span><span class="n">potential</span><span class="p">,</span>
                              <span class="n">return_pair_info</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
    <span class="n">lammps_variables</span><span class="p">[</span><span class="s1">&#39;atomman_system_pair_info&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">system_info</span>
    <span class="n">lammps_variables</span><span class="p">[</span><span class="s1">&#39;fix_cut_setforce&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">fix_cut_setforce</span>
    <span class="n">lammps_variables</span><span class="p">[</span><span class="s1">&#39;sim_directory&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">sim_directory</span>
    <span class="n">lammps_variables</span><span class="p">[</span><span class="s1">&#39;etol&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">etol</span>
    <span class="n">lammps_variables</span><span class="p">[</span><span class="s1">&#39;ftol&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">uc</span><span class="o">.</span><span class="n">get_in_units</span><span class="p">(</span><span class="n">ftol</span><span class="p">,</span> <span class="n">lammps_units</span><span class="p">[</span><span class="s1">&#39;force&#39;</span><span class="p">])</span>
    <span class="n">lammps_variables</span><span class="p">[</span><span class="s1">&#39;maxiter&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">maxiter</span>
    <span class="n">lammps_variables</span><span class="p">[</span><span class="s1">&#39;maxeval&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">maxeval</span>
    <span class="n">lammps_variables</span><span class="p">[</span><span class="s1">&#39;dmax&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">uc</span><span class="o">.</span><span class="n">get_in_units</span><span class="p">(</span><span class="n">dmax</span><span class="p">,</span> <span class="n">lammps_units</span><span class="p">[</span><span class="s1">&#39;length&#39;</span><span class="p">])</span>

    <span class="c1"># Set dump_modify format based on dump_modify_version</span>
    <span class="k">if</span> <span class="n">lammps_date</span> <span class="o">&lt;</span> <span class="n">datetime</span><span class="o">.</span><span class="n">date</span><span class="p">(</span><span class="mi">2016</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="mi">3</span><span class="p">):</span>
        <span class="n">lammps_variables</span><span class="p">[</span><span class="s1">&#39;dump_modify_format&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;&quot;</span><span class="si">%i</span><span class="s1"> </span><span class="si">%i</span><span class="s1"> </span><span class="si">%.13e</span><span class="s1"> </span><span class="si">%.13e</span><span class="s1"> </span><span class="si">%.13e</span><span class="s1"> </span><span class="si">%.13e</span><span class="s1">&quot;&#39;</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="n">lammps_variables</span><span class="p">[</span><span class="s1">&#39;dump_modify_format&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;float </span><span class="si">%.13e</span><span class="s1">&#39;</span>

    <span class="c1"># Write lammps input script</span>
    <span class="n">template_file</span> <span class="o">=</span> <span class="s1">&#39;sfmin.template&#39;</span>
    <span class="n">lammps_script</span> <span class="o">=</span> <span class="n">Path</span><span class="p">(</span><span class="n">sim_directory</span><span class="p">,</span> <span class="s1">&#39;sfmin.in&#39;</span><span class="p">)</span>
    <span class="n">template</span> <span class="o">=</span> <span class="n">iprPy</span><span class="o">.</span><span class="n">tools</span><span class="o">.</span><span class="n">read_calc_file</span><span class="p">(</span><span class="n">template_file</span><span class="p">,</span> <span class="n">filedict</span><span class="p">)</span>
    <span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">lammps_script</span><span class="p">,</span> <span class="s1">&#39;w&#39;</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
        <span class="n">f</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">iprPy</span><span class="o">.</span><span class="n">tools</span><span class="o">.</span><span class="n">filltemplate</span><span class="p">(</span><span class="n">template</span><span class="p">,</span> <span class="n">lammps_variables</span><span class="p">,</span>
                                         <span class="s1">&#39;&lt;&#39;</span><span class="p">,</span> <span class="s1">&#39;&gt;&#39;</span><span class="p">))</span>

    <span class="c1"># Run LAMMPS</span>
    <span class="n">output</span> <span class="o">=</span> <span class="n">lmp</span><span class="o">.</span><span class="n">run</span><span class="p">(</span><span class="n">lammps_command</span><span class="p">,</span> <span class="n">lammps_script</span><span class="o">.</span><span class="n">as_posix</span><span class="p">(),</span> <span class="n">mpi_command</span><span class="p">,</span>
                     <span class="n">logfile</span><span class="o">=</span><span class="n">Path</span><span class="p">(</span><span class="n">sim_directory</span><span class="p">,</span> <span class="s1">&#39;log.lammps&#39;</span><span class="p">)</span><span class="o">.</span><span class="n">as_posix</span><span class="p">())</span>

    <span class="c1"># Extract output values</span>
    <span class="n">thermo</span> <span class="o">=</span> <span class="n">output</span><span class="o">.</span><span class="n">simulations</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">][</span><span class="s1">&#39;thermo&#39;</span><span class="p">]</span>
    <span class="n">logfile</span> <span class="o">=</span> <span class="n">Path</span><span class="p">(</span><span class="n">sim_directory</span><span class="p">,</span> <span class="s1">&#39;log.lammps&#39;</span><span class="p">)</span><span class="o">.</span><span class="n">as_posix</span><span class="p">()</span>
    <span class="n">dumpfile</span> <span class="o">=</span> <span class="n">Path</span><span class="p">(</span><span class="n">sim_directory</span><span class="p">,</span> <span class="n">f</span><span class="s1">&#39;</span><span class="si">{thermo.Step.values[-1]}</span><span class="s1">.dump&#39;</span><span class="p">)</span><span class="o">.</span><span class="n">as_posix</span><span class="p">()</span>
    <span class="n">E_total</span> <span class="o">=</span> <span class="n">uc</span><span class="o">.</span><span class="n">set_in_units</span><span class="p">(</span><span class="n">thermo</span><span class="o">.</span><span class="n">PotEng</span><span class="o">.</span><span class="n">values</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">],</span>
                              <span class="n">lammps_units</span><span class="p">[</span><span class="s1">&#39;energy&#39;</span><span class="p">])</span>

    <span class="c1"># Load relaxed system</span>
    <span class="n">system</span> <span class="o">=</span> <span class="n">am</span><span class="o">.</span><span class="n">load</span><span class="p">(</span><span class="s1">&#39;atom_dump&#39;</span><span class="p">,</span> <span class="n">dumpfile</span><span class="p">,</span> <span class="n">symbols</span><span class="o">=</span><span class="n">system</span><span class="o">.</span><span class="n">symbols</span><span class="p">)</span>

    <span class="c1"># Return results</span>
    <span class="n">results_dict</span> <span class="o">=</span> <span class="p">{}</span>
    <span class="n">results_dict</span><span class="p">[</span><span class="s1">&#39;logfile&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">logfile</span>
    <span class="n">results_dict</span><span class="p">[</span><span class="s1">&#39;dumpfile&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">dumpfile</span>
    <span class="n">results_dict</span><span class="p">[</span><span class="s1">&#39;system&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">system</span>
    <span class="n">results_dict</span><span class="p">[</span><span class="s1">&#39;E_total&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">E_total</span>

    <span class="k">return</span> <span class="n">results_dict</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="3.3-stackingfault()">
<h4>3.3 stackingfault()<a class="headerlink" href="#3.3-stackingfault()" title="Permalink to this headline">¶</a></h4>
<div class="nbinput nblast docutils container">
<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[11]:
</pre></div>
</div>
<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
<span></span><span class="k">def</span> <span class="nf">stackingfault</span><span class="p">(</span><span class="n">lammps_command</span><span class="p">,</span> <span class="n">ucell</span><span class="p">,</span> <span class="n">potential</span><span class="p">,</span> <span class="n">hkl</span><span class="p">,</span>
                  <span class="n">mpi_command</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">sizemults</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">minwidth</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">even</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
                  <span class="n">a1vect_uvw</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">a2vect_uvw</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">conventional_setting</span><span class="o">=</span><span class="s1">&#39;p&#39;</span><span class="p">,</span>
                  <span class="n">cutboxvector</span><span class="o">=</span><span class="s1">&#39;c&#39;</span><span class="p">,</span> <span class="n">faultpos_rel</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">faultpos_cart</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span>
                  <span class="n">a1</span><span class="o">=</span><span class="mf">0.0</span><span class="p">,</span> <span class="n">a2</span><span class="o">=</span><span class="mf">0.0</span><span class="p">,</span> <span class="n">atomshift</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">shiftindex</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span>
                  <span class="n">etol</span><span class="o">=</span><span class="mf">0.0</span><span class="p">,</span> <span class="n">ftol</span><span class="o">=</span><span class="mf">0.0</span><span class="p">,</span> <span class="n">maxiter</span><span class="o">=</span><span class="mi">10000</span><span class="p">,</span> <span class="n">maxeval</span><span class="o">=</span><span class="mi">100000</span><span class="p">,</span>
                  <span class="n">dmax</span><span class="o">=</span><span class="n">uc</span><span class="o">.</span><span class="n">set_in_units</span><span class="p">(</span><span class="mf">0.01</span><span class="p">,</span> <span class="s1">&#39;angstrom&#39;</span><span class="p">)):</span>
    <span class="sd">&quot;&quot;&quot;</span>
<span class="sd">    Computes the generalized stacking fault value for a single faultshift.</span>

<span class="sd">    Parameters</span>
<span class="sd">    ----------</span>
<span class="sd">    lammps_command :str</span>
<span class="sd">        Command for running LAMMPS.</span>
<span class="sd">    ucell : atomman.System</span>
<span class="sd">        The crystal unit cell to use as the basis of the stacking fault</span>
<span class="sd">        configurations.</span>
<span class="sd">    potential : atomman.lammps.Potential</span>
<span class="sd">        The LAMMPS implemented potential to use.</span>
<span class="sd">    hkl : array-like object</span>
<span class="sd">        The Miller(-Bravais) crystal fault plane relative to ucell.</span>
<span class="sd">    mpi_command : str, optional</span>
<span class="sd">        The MPI command for running LAMMPS in parallel.  If not given, LAMMPS</span>
<span class="sd">        will run serially.</span>
<span class="sd">    sizemults : list or tuple, optional</span>
<span class="sd">        The three System.supersize multipliers [a_mult, b_mult, c_mult] to use on the</span>
<span class="sd">        rotated cell to build the final system. Note that the cutboxvector sizemult</span>
<span class="sd">        must be an integer and not a tuple.  Default value is [1, 1, 1].</span>
<span class="sd">    minwidth : float, optional</span>
<span class="sd">        If given, the sizemult along the cutboxvector will be selected such that the</span>
<span class="sd">        width of the resulting final system in that direction will be at least this</span>
<span class="sd">        value. If both sizemults and minwidth are given, then the larger of the two</span>
<span class="sd">        in the cutboxvector direction will be used.</span>
<span class="sd">    even : bool, optional</span>
<span class="sd">        A True value means that the sizemult for cutboxvector will be made an even</span>
<span class="sd">        number by adding 1 if it is odd.  Default value is False.</span>
<span class="sd">    a1vect_uvw : array-like object, optional</span>
<span class="sd">        The crystal vector to use for one of the two shifting vectors.  If</span>
<span class="sd">        not given, will be set to the shortest in-plane lattice vector.</span>
<span class="sd">    a2vect_uvw : array-like object, optional</span>
<span class="sd">        The crystal vector to use for one of the two shifting vectors.  If</span>
<span class="sd">        not given, will be set to the shortest in-plane lattice vector not</span>
<span class="sd">        parallel to a1vect_uvw.</span>
<span class="sd">    conventional_setting : str, optional</span>
<span class="sd">        Allows for rotations of a primitive unit cell to be determined from</span>
<span class="sd">        (hkl) indices specified relative to a conventional unit cell.  Allowed</span>
<span class="sd">        settings: &#39;p&#39; for primitive (no conversion), &#39;f&#39; for face-centered,</span>
<span class="sd">        &#39;i&#39; for body-centered, and &#39;a&#39;, &#39;b&#39;, or &#39;c&#39; for side-centered.  Default</span>
<span class="sd">        behavior is to perform no conversion, i.e. take (hkl) relative to the</span>
<span class="sd">        given ucell.</span>
<span class="sd">    cutboxvector : str, optional</span>
<span class="sd">        Indicates which of the three system box vectors, &#39;a&#39;, &#39;b&#39;, or &#39;c&#39;, to</span>
<span class="sd">        cut with a non-periodic boundary (default is &#39;c&#39;).</span>
<span class="sd">    faultpos_rel : float, optional</span>
<span class="sd">        The position to place the slip plane within the system given as a</span>
<span class="sd">        relative coordinate along the out-of-plane direction.  faultpos_rel</span>
<span class="sd">        and faultpos_cart cannot both be given.  Default value is 0.5 if</span>
<span class="sd">        faultpos_cart is also not given.</span>
<span class="sd">    faultpos_cart : float, optional</span>
<span class="sd">        The position to place the slip plane within the system given as a</span>
<span class="sd">        Cartesian coordinate along the out-of-plane direction.  faultpos_rel</span>
<span class="sd">        and faultpos_cart cannot both be given.</span>
<span class="sd">    a1 : float, optional</span>
<span class="sd">        The fractional coordinate to evaluate along a1vect_uvw.</span>
<span class="sd">        Default value is 0.0.</span>
<span class="sd">    a2 : float, optional</span>
<span class="sd">        The fractional coordinate to evaluate along a2vect_uvw.</span>
<span class="sd">        Default value is 0.0.</span>
<span class="sd">    atomshift : array-like object, optional</span>
<span class="sd">        A Cartesian vector shift to apply to all atoms.  Can be used to shift</span>
<span class="sd">        atoms perpendicular to the fault plane to allow different termination</span>
<span class="sd">        planes to be cut.  Cannot be given with shiftindex.</span>
<span class="sd">    shiftindex : int, optional</span>
<span class="sd">        Allows for selection of different termination planes based on the</span>
<span class="sd">        preferred shift values determined by the underlying fault generation.</span>
<span class="sd">        Cannot be given with atomshift. If neither atomshift nor shiftindex</span>
<span class="sd">        given, then shiftindex will be set to 0.</span>
<span class="sd">    etol : float, optional</span>
<span class="sd">        The energy tolerance for the structure minimization. This value is</span>
<span class="sd">        unitless. (Default is 0.0).</span>
<span class="sd">    ftol : float, optional</span>
<span class="sd">        The force tolerance for the structure minimization. This value is in</span>
<span class="sd">        units of force. (Default is 0.0).</span>
<span class="sd">    maxiter : int, optional</span>
<span class="sd">        The maximum number of minimization iterations to use (default is</span>
<span class="sd">        10000).</span>
<span class="sd">    maxeval : int, optional</span>
<span class="sd">        The maximum number of minimization evaluations to use (default is</span>
<span class="sd">        100000).</span>
<span class="sd">    dmax : float, optional</span>
<span class="sd">        The maximum distance in length units that any atom is allowed to relax</span>
<span class="sd">        in any direction during a single minimization iteration (default is</span>
<span class="sd">        0.01 Angstroms).</span>

<span class="sd">    Returns</span>
<span class="sd">    -------</span>
<span class="sd">    dict</span>
<span class="sd">        Dictionary of results consisting of keys:</span>

<span class="sd">        - **&#39;E_gsf&#39;** (*float*) - The stacking fault formation energy.</span>
<span class="sd">        - **&#39;E_total_0&#39;** (*float*) - The total potential energy of the</span>
<span class="sd">          system before applying the faultshift.</span>
<span class="sd">        - **&#39;E_total_sf&#39;** (*float*) - The total potential energy of the</span>
<span class="sd">          system after applying the faultshift.</span>
<span class="sd">        - **&#39;delta_disp&#39;** (*float*) - The change in the center of mass</span>
<span class="sd">          difference between before and after applying the faultshift.</span>
<span class="sd">        - **&#39;disp_0&#39;** (*float*) - The center of mass difference between atoms</span>
<span class="sd">          above and below the fault plane in the cutboxvector direction for</span>
<span class="sd">          the system before applying the faultshift.</span>
<span class="sd">        - **&#39;disp_sf&#39;** (*float*) - The center of mass difference between</span>
<span class="sd">          atoms above and below the fault plane in the cutboxvector direction</span>
<span class="sd">          for the system after applying the faultshift.</span>
<span class="sd">        - **&#39;A_fault&#39;** (*float*) - The area of the fault surface.</span>
<span class="sd">        - **&#39;dumpfile_0&#39;** (*str*) - The name of the LAMMMPS dump file</span>
<span class="sd">          associated with the relaxed system before applying the faultshift.</span>
<span class="sd">        - **&#39;dumpfile_sf&#39;** (*str*) - The name of the LAMMMPS dump file</span>
<span class="sd">          associated with the relaxed system after applying the faultshift.</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="c1"># Construct stacking fault configuration generator</span>
    <span class="n">gsf_gen</span> <span class="o">=</span> <span class="n">am</span><span class="o">.</span><span class="n">defect</span><span class="o">.</span><span class="n">StackingFault</span><span class="p">(</span><span class="n">hkl</span><span class="p">,</span> <span class="n">ucell</span><span class="p">,</span> <span class="n">cutboxvector</span><span class="o">=</span><span class="n">cutboxvector</span><span class="p">,</span>
                                      <span class="n">a1vect_uvw</span><span class="o">=</span><span class="n">a1vect_uvw</span><span class="p">,</span> <span class="n">a2vect_uvw</span><span class="o">=</span><span class="n">a2vect_uvw</span><span class="p">,</span>
                                      <span class="n">conventional_setting</span><span class="o">=</span><span class="n">conventional_setting</span><span class="p">)</span>

    <span class="c1"># Check shift parameters</span>
    <span class="k">if</span> <span class="n">shiftindex</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
        <span class="k">assert</span> <span class="n">atomshift</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">,</span> <span class="s1">&#39;shiftindex and atomshift cannot both be given&#39;</span>
        <span class="n">atomshift</span> <span class="o">=</span> <span class="n">gsf_gen</span><span class="o">.</span><span class="n">shifts</span><span class="p">[</span><span class="n">shiftindex</span><span class="p">]</span>
    <span class="k">elif</span> <span class="n">atomshift</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
        <span class="n">atomshift</span> <span class="o">=</span> <span class="n">gsf_gen</span><span class="o">.</span><span class="n">shifts</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>

    <span class="c1"># Generate the free surface (zero-shift) configuration</span>
    <span class="n">sfsystem</span> <span class="o">=</span> <span class="n">gsf_gen</span><span class="o">.</span><span class="n">surface</span><span class="p">(</span><span class="n">shift</span><span class="o">=</span><span class="n">atomshift</span><span class="p">,</span> <span class="n">minwidth</span><span class="o">=</span><span class="n">minwidth</span><span class="p">,</span>
                               <span class="n">sizemults</span><span class="o">=</span><span class="n">sizemults</span><span class="p">,</span> <span class="n">even</span><span class="o">=</span><span class="n">even</span><span class="p">,</span>
                               <span class="n">faultpos_rel</span><span class="o">=</span><span class="n">faultpos_rel</span><span class="p">)</span>

    <span class="n">abovefault</span> <span class="o">=</span> <span class="n">gsf_gen</span><span class="o">.</span><span class="n">abovefault</span>
    <span class="n">cutindex</span> <span class="o">=</span> <span class="n">gsf_gen</span><span class="o">.</span><span class="n">cutindex</span>
    <span class="n">A_fault</span> <span class="o">=</span> <span class="n">gsf_gen</span><span class="o">.</span><span class="n">surfacearea</span>

    <span class="c1"># Identify lammps_date version</span>
    <span class="n">lammps_date</span> <span class="o">=</span> <span class="n">lmp</span><span class="o">.</span><span class="n">checkversion</span><span class="p">(</span><span class="n">lammps_command</span><span class="p">)[</span><span class="s1">&#39;date&#39;</span><span class="p">]</span>


    <span class="c1"># Evaluate the zero shift configuration</span>
    <span class="n">zeroshift</span> <span class="o">=</span> <span class="n">stackingfaultrelax</span><span class="p">(</span><span class="n">lammps_command</span><span class="p">,</span> <span class="n">sfsystem</span><span class="p">,</span> <span class="n">potential</span><span class="p">,</span>
                                   <span class="n">mpi_command</span><span class="o">=</span><span class="n">mpi_command</span><span class="p">,</span>
                                   <span class="n">cutboxvector</span><span class="o">=</span><span class="n">cutboxvector</span><span class="p">,</span>
                                   <span class="n">etol</span><span class="o">=</span><span class="n">etol</span><span class="p">,</span> <span class="n">ftol</span><span class="o">=</span><span class="n">ftol</span><span class="p">,</span> <span class="n">maxiter</span><span class="o">=</span><span class="n">maxiter</span><span class="p">,</span>
                                   <span class="n">maxeval</span><span class="o">=</span><span class="n">maxeval</span><span class="p">,</span> <span class="n">dmax</span><span class="o">=</span><span class="n">dmax</span><span class="p">,</span>
                                   <span class="n">lammps_date</span><span class="o">=</span><span class="n">lammps_date</span><span class="p">)</span>

    <span class="c1"># Extract terms</span>
    <span class="n">E_total_0</span> <span class="o">=</span> <span class="n">zeroshift</span><span class="p">[</span><span class="s1">&#39;E_total&#39;</span><span class="p">]</span>
    <span class="n">pos_0</span> <span class="o">=</span> <span class="n">zeroshift</span><span class="p">[</span><span class="s1">&#39;system&#39;</span><span class="p">]</span><span class="o">.</span><span class="n">atoms</span><span class="o">.</span><span class="n">pos</span>
    <span class="n">shutil</span><span class="o">.</span><span class="n">move</span><span class="p">(</span><span class="s1">&#39;log.lammps&#39;</span><span class="p">,</span> <span class="s1">&#39;zeroshift-log.lammps&#39;</span><span class="p">)</span>
    <span class="n">shutil</span><span class="o">.</span><span class="n">move</span><span class="p">(</span><span class="n">zeroshift</span><span class="p">[</span><span class="s1">&#39;dumpfile&#39;</span><span class="p">],</span> <span class="s1">&#39;zeroshift.dump&#39;</span><span class="p">)</span>

    <span class="c1"># Evaluate the system after shifting along the fault plane</span>
    <span class="n">sfsystem</span> <span class="o">=</span> <span class="n">gsf_gen</span><span class="o">.</span><span class="n">fault</span><span class="p">(</span><span class="n">a1</span><span class="o">=</span><span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="o">=</span><span class="n">a2</span><span class="p">)</span>
    <span class="n">shifted</span> <span class="o">=</span> <span class="n">stackingfaultrelax</span><span class="p">(</span><span class="n">lammps_command</span><span class="p">,</span> <span class="n">sfsystem</span><span class="p">,</span> <span class="n">potential</span><span class="p">,</span>
                                 <span class="n">mpi_command</span><span class="o">=</span><span class="n">mpi_command</span><span class="p">,</span>
                                 <span class="n">cutboxvector</span><span class="o">=</span><span class="n">cutboxvector</span><span class="p">,</span>
                                 <span class="n">etol</span><span class="o">=</span><span class="n">etol</span><span class="p">,</span> <span class="n">ftol</span><span class="o">=</span><span class="n">ftol</span><span class="p">,</span> <span class="n">maxiter</span><span class="o">=</span><span class="n">maxiter</span><span class="p">,</span>
                                 <span class="n">maxeval</span><span class="o">=</span><span class="n">maxeval</span><span class="p">,</span> <span class="n">dmax</span><span class="o">=</span><span class="n">dmax</span><span class="p">,</span>
                                 <span class="n">lammps_date</span><span class="o">=</span><span class="n">lammps_date</span><span class="p">)</span>

    <span class="c1"># Extract terms</span>
    <span class="n">E_total_sf</span> <span class="o">=</span> <span class="n">shifted</span><span class="p">[</span><span class="s1">&#39;E_total&#39;</span><span class="p">]</span>
    <span class="n">pos_sf</span> <span class="o">=</span> <span class="n">shifted</span><span class="p">[</span><span class="s1">&#39;system&#39;</span><span class="p">]</span><span class="o">.</span><span class="n">atoms</span><span class="o">.</span><span class="n">pos</span>
    <span class="n">shutil</span><span class="o">.</span><span class="n">move</span><span class="p">(</span><span class="s1">&#39;log.lammps&#39;</span><span class="p">,</span> <span class="s1">&#39;shifted-log.lammps&#39;</span><span class="p">)</span>
    <span class="n">shutil</span><span class="o">.</span><span class="n">move</span><span class="p">(</span><span class="n">shifted</span><span class="p">[</span><span class="s1">&#39;dumpfile&#39;</span><span class="p">],</span> <span class="s1">&#39;shifted.dump&#39;</span><span class="p">)</span>

    <span class="c1"># Compute the stacking fault energy</span>
    <span class="n">E_gsf</span> <span class="o">=</span> <span class="p">(</span><span class="n">E_total_sf</span> <span class="o">-</span> <span class="n">E_total_0</span><span class="p">)</span> <span class="o">/</span> <span class="n">A_fault</span>

    <span class="c1"># Compute the change in displacement normal to fault plane</span>
    <span class="n">disp_0</span> <span class="o">=</span> <span class="p">(</span><span class="n">pos_0</span><span class="p">[</span><span class="n">abovefault</span><span class="p">,</span> <span class="n">cutindex</span><span class="p">]</span><span class="o">.</span><span class="n">mean</span><span class="p">()</span>
            <span class="o">-</span> <span class="n">pos_0</span><span class="p">[</span><span class="o">~</span><span class="n">abovefault</span><span class="p">,</span> <span class="n">cutindex</span><span class="p">]</span><span class="o">.</span><span class="n">mean</span><span class="p">())</span>
    <span class="n">disp_sf</span> <span class="o">=</span> <span class="p">(</span><span class="n">pos_sf</span><span class="p">[</span><span class="n">abovefault</span><span class="p">,</span> <span class="n">cutindex</span><span class="p">]</span><span class="o">.</span><span class="n">mean</span><span class="p">()</span>
             <span class="o">-</span> <span class="n">pos_sf</span><span class="p">[</span><span class="o">~</span><span class="n">abovefault</span><span class="p">,</span> <span class="n">cutindex</span><span class="p">]</span><span class="o">.</span><span class="n">mean</span><span class="p">())</span>
    <span class="n">delta_disp</span> <span class="o">=</span> <span class="n">disp_sf</span> <span class="o">-</span> <span class="n">disp_0</span>

    <span class="c1"># Return processed results</span>
    <span class="n">results</span> <span class="o">=</span> <span class="p">{}</span>
    <span class="n">results</span><span class="p">[</span><span class="s1">&#39;E_gsf&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">E_gsf</span>
    <span class="n">results</span><span class="p">[</span><span class="s1">&#39;E_total_0&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">E_total_0</span>
    <span class="n">results</span><span class="p">[</span><span class="s1">&#39;E_total_sf&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">E_total_sf</span>
    <span class="n">results</span><span class="p">[</span><span class="s1">&#39;delta_disp&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">delta_disp</span>
    <span class="n">results</span><span class="p">[</span><span class="s1">&#39;disp_0&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">disp_0</span>
    <span class="n">results</span><span class="p">[</span><span class="s1">&#39;disp_sf&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">disp_sf</span>
    <span class="n">results</span><span class="p">[</span><span class="s1">&#39;A_fault&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">A_fault</span>
    <span class="n">results</span><span class="p">[</span><span class="s1">&#39;dumpfile_0&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;zeroshift.dump&#39;</span>
    <span class="n">results</span><span class="p">[</span><span class="s1">&#39;dumpfile_sf&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;shifted.dump&#39;</span>

    <span class="k">return</span> <span class="n">results</span>
</pre></div>
</div>
</div>
</div>
</div>
<div class="section" id="4.-Run-calculation-function(s)">
<h3>4. Run calculation function(s)<a class="headerlink" href="#4.-Run-calculation-function(s)" title="Permalink to this headline">¶</a></h3>
<div class="nbinput nblast docutils container">
<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[12]:
</pre></div>
</div>
<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
<span></span><span class="n">results_dict</span> <span class="o">=</span> <span class="n">stackingfault</span><span class="p">(</span><span class="n">lammps_command</span><span class="p">,</span> <span class="n">ucell</span><span class="p">,</span> <span class="n">potential</span><span class="p">,</span> <span class="n">hkl</span><span class="p">,</span>
                             <span class="n">mpi_command</span> <span class="o">=</span> <span class="n">mpi_command</span><span class="p">,</span>
                             <span class="n">sizemults</span> <span class="o">=</span> <span class="n">sizemults</span><span class="p">,</span>
                             <span class="n">minwidth</span> <span class="o">=</span> <span class="n">minwidth</span><span class="p">,</span>
                             <span class="n">a1vect_uvw</span> <span class="o">=</span> <span class="n">a1vect_uvw</span><span class="p">,</span>
                             <span class="n">a2vect_uvw</span> <span class="o">=</span> <span class="n">a2vect_uvw</span><span class="p">,</span>
                             <span class="n">cutboxvector</span> <span class="o">=</span> <span class="n">cutboxvector</span><span class="p">,</span>
                             <span class="n">shiftindex</span> <span class="o">=</span> <span class="n">shiftindex</span><span class="p">,</span>
                             <span class="n">a1</span> <span class="o">=</span> <span class="n">a1</span><span class="p">,</span>
                             <span class="n">a2</span> <span class="o">=</span> <span class="n">a2</span><span class="p">,</span>
                             <span class="n">etol</span> <span class="o">=</span> <span class="n">energytolerance</span><span class="p">,</span>
                             <span class="n">ftol</span> <span class="o">=</span> <span class="n">forcetolerance</span><span class="p">,</span>
                             <span class="n">maxiter</span> <span class="o">=</span> <span class="n">maxiterations</span><span class="p">,</span>
                             <span class="n">maxeval</span> <span class="o">=</span> <span class="n">maxevaluations</span><span class="p">,</span>
                             <span class="n">dmax</span> <span class="o">=</span> <span class="n">maxatommotion</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="nbinput docutils container">
<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[13]:
</pre></div>
</div>
<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
<span></span><span class="n">results_dict</span><span class="o">.</span><span class="n">keys</span><span class="p">()</span>
</pre></div>
</div>
</div>
<div class="nboutput nblast docutils container">
<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[13]:
</pre></div>
</div>
<div class="output_area docutils container">
<div class="highlight"><pre>
dict_keys([&#39;E_gsf&#39;, &#39;E_total_0&#39;, &#39;E_total_sf&#39;, &#39;delta_disp&#39;, &#39;disp_0&#39;, &#39;disp_sf&#39;, &#39;A_fault&#39;, &#39;dumpfile_0&#39;, &#39;dumpfile_sf&#39;])
</pre></div></div>
</div>
</div>
<div class="section" id="5.-Report-results">
<h3>5. Report results<a class="headerlink" href="#5.-Report-results" title="Permalink to this headline">¶</a></h3>
<div class="section" id="5.1-Define-units-for-outputting-values">
<h4>5.1 Define units for outputting values<a class="headerlink" href="#5.1-Define-units-for-outputting-values" title="Permalink to this headline">¶</a></h4>
<ul class="simple">
<li><p><strong>length_unit</strong> is the unit of area to display delta displacemets in.</p></li>
<li><p><strong>area_unit</strong> is the unit of area to display fault area in.</p></li>
<li><p><strong>energyperarea_unit</strong> is the energy per area to report the surface energy in.</p></li>
</ul>
<div class="nbinput nblast docutils container">
<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[14]:
</pre></div>
</div>
<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
<span></span><span class="n">length_unit</span> <span class="o">=</span> <span class="s1">&#39;nm&#39;</span>
<span class="n">area_unit</span> <span class="o">=</span> <span class="s1">&#39;nm^2&#39;</span>
<span class="n">energyperarea_unit</span> <span class="o">=</span> <span class="s1">&#39;mJ/m^2&#39;</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="5.2-Print-A_{fault},-E_{gsf},-and-\Delta\delta">
<h4>5.2 Print <span class="math notranslate nohighlight">\(A_{fault}\)</span>, <span class="math notranslate nohighlight">\(E_{gsf}\)</span>, and <span class="math notranslate nohighlight">\(\Delta\delta\)</span><a class="headerlink" href="#5.2-Print-A_{fault},-E_{gsf},-and-\Delta\delta" title="Permalink to this headline">¶</a></h4>
<div class="nbinput docutils container">
<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[15]:
</pre></div>
</div>
<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
<span></span><span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Values for fractional shift = (</span><span class="si">%f</span><span class="s1">, </span><span class="si">%f</span><span class="s1">)&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="p">))</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;A_fault =    &#39;</span><span class="p">,</span> <span class="n">uc</span><span class="o">.</span><span class="n">get_in_units</span><span class="p">(</span><span class="n">results_dict</span><span class="p">[</span><span class="s1">&#39;A_fault&#39;</span><span class="p">],</span> <span class="n">area_unit</span><span class="p">),</span> <span class="n">area_unit</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;E_gsf =      &#39;</span><span class="p">,</span> <span class="n">uc</span><span class="o">.</span><span class="n">get_in_units</span><span class="p">(</span><span class="n">results_dict</span><span class="p">[</span><span class="s1">&#39;E_gsf&#39;</span><span class="p">],</span> <span class="n">energyperarea_unit</span><span class="p">),</span> <span class="n">energyperarea_unit</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;delta_disp = &#39;</span><span class="p">,</span> <span class="n">uc</span><span class="o">.</span><span class="n">get_in_units</span><span class="p">(</span><span class="n">results_dict</span><span class="p">[</span><span class="s1">&#39;delta_disp&#39;</span><span class="p">],</span> <span class="n">length_unit</span><span class="p">),</span> <span class="n">length_unit</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="nboutput nblast docutils container">
<div class="prompt empty docutils container">
</div>
<div class="output_area docutils container">
<div class="highlight"><pre>
Values for fractional shift = (0.500000, 0.000000)
A_fault =     5.365198866947918 nm^2
E_gsf =       924.3579463239225 mJ/m^2
delta_disp =  0.015655877018008368 nm
</pre></div></div>
</div>
</div>
</div>
</div>
</div>


          </div>
        </div>
      </div>
      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
        <div class="sphinxsidebarwrapper">
  <h3><a href="../index.html">Table of Contents</a></h3>
  <ul>
<li><a class="reference internal" href="#">stacking_fault_static calculation style</a><ul>
<li><a class="reference internal" href="#Introduction">Introduction</a><ul>
<li><a class="reference internal" href="#Version-notes">Version notes</a></li>
<li><a class="reference internal" href="#Additional-dependencies">Additional dependencies</a></li>
<li><a class="reference internal" href="#Disclaimers">Disclaimers</a></li>
</ul>
</li>
<li><a class="reference internal" href="#Method-and-Theory">Method and Theory</a></li>
<li><a class="reference internal" href="#Demonstration">Demonstration</a><ul>
<li><a class="reference internal" href="#1.-Library-imports">1. Library imports</a><ul>
<li><a class="reference internal" href="#1.2.-Default-calculation-setup">1.2. Default calculation setup</a></li>
</ul>
</li>
<li><a class="reference internal" href="#2.-Assign-values-for-the-calculation’s-run-parameters">2. Assign values for the calculation’s run parameters</a><ul>
<li><a class="reference internal" href="#2.1-Specify-system-specific-paths">2.1 Specify system-specific paths</a></li>
<li><a class="reference internal" href="#2.2.-Load-interatomic-potential">2.2. Load interatomic potential</a></li>
<li><a class="reference internal" href="#2.3.-Load-initial-unit-cell-system">2.3. Load initial unit cell system</a></li>
<li><a class="reference internal" href="#2.4.-Specify-the-defect-parameters">2.4. Specify the defect parameters</a></li>
<li><a class="reference internal" href="#2.5.-Modify-system">2.5. Modify system</a></li>
<li><a class="reference internal" href="#2.6.-Specify-calculation-specific-run-parameters">2.6. Specify calculation-specific run parameters</a></li>
</ul>
</li>
<li><a class="reference internal" href="#3.-Define-calculation-function(s)-and-generate-template-LAMMPS-script(s)">3. Define calculation function(s) and generate template LAMMPS script(s)</a><ul>
<li><a class="reference internal" href="#3.1-sfmin.template">3.1 sfmin.template</a></li>
<li><a class="reference internal" href="#3.2-stackingfaultrelax()">3.2 stackingfaultrelax()</a></li>
<li><a class="reference internal" href="#3.3-stackingfault()">3.3 stackingfault()</a></li>
</ul>
</li>
<li><a class="reference internal" href="#4.-Run-calculation-function(s)">4. Run calculation function(s)</a></li>
<li><a class="reference internal" href="#5.-Report-results">5. Report results</a><ul>
<li><a class="reference internal" href="#5.1-Define-units-for-outputting-values">5.1 Define units for outputting values</a></li>
<li><a class="reference internal" href="#5.2-Print-A_{fault},-E_{gsf},-and-\Delta\delta">5.2 Print <span class="math notranslate nohighlight">\(A_{fault}\)</span>, <span class="math notranslate nohighlight">\(E_{gsf}\)</span>, and <span class="math notranslate nohighlight">\(\Delta\delta\)</span></a></li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>

  <h4>Previous topic</h4>
  <p class="topless"><a href="stacking_fault_map_2D.html"
                        title="previous chapter">stacking_fault_map_2D calculation style</a></p>
  <h4>Next topic</h4>
  <p class="topless"><a href="surface_energy_static.html"
                        title="next chapter">surface_energy_static calculation style</a></p>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="related" role="navigation" aria-label="related navigation">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="../genindex.html" title="General Index"
             >index</a></li>
        <li class="right" >
          <a href="../py-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="surface_energy_static.html" title="surface_energy_static calculation style"
             >next</a> |</li>
        <li class="right" >
          <a href="stacking_fault_map_2D.html" title="stacking_fault_map_2D calculation style"
             >previous</a> |</li>
        <li class="nav-item nav-item-0"><a href="../index.html">iprPy 0.10.2 documentation</a> &#187;</li>
          <li class="nav-item nav-item-1"><a href="../notebook_styles.html" >Jupyter Demonstration Notebooks</a> &#187;</li> 
      </ul>
    </div>
    <div class="footer" role="contentinfo">
      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 2.1.2.
    </div>
  </body>
</html>